Latviešu

Atklājiet TypeScript `const` apgalvojumu spēku nemainīgai tipu secināšanai, uzlabojot koda drošību un paredzamību jūsu projektos. Uzziniet, kā tos efektīvi izmantot.

TypeScript `const` apgalvojumi: Nemainīga tipu secināšana robustam kodam

TypeScript, kas ir JavaScript virskopa, ienes statisko tipēšanu dinamiskajā tīmekļa izstrādes pasaulē. Viena no tā jaudīgajām funkcijām ir tipu secināšana (type inference), kur kompilators automātiski nosaka mainīgā tipu. `Const` apgalvojumi, kas ieviesti TypeScript 3.4 versijā, paceļ tipu secināšanu jaunā līmenī, ļaujot jums ieviest nemainīgumu (immutability) un veidot robustāku un paredzamāku kodu.

Kas ir `const` apgalvojumi?

`Const` apgalvojumi ir veids, kā paziņot TypeScript kompilatoram, ka vērtībai ir jābūt nemainīgai. Tos piemēro, izmantojot as const sintaksi aiz literālas vērtības vai izteiksmes. Tas norāda kompilatoram secināt šaurāko iespējamo (literālo) tipu izteiksmei un atzīmēt visas īpašības kā readonly.

Būtībā `const` apgalvojumi nodrošina spēcīgāku tipu drošības līmeni nekā vienkārša mainīgā deklarēšana ar const. Lai gan const novērš paša mainīgā atkārtotu piešķiršanu, tas nenovērš objekta vai masīva, uz kuru mainīgais atsaucas, modificēšanu. `Const` apgalvojumi novērš arī objekta īpašību modificēšanu.

`Const` apgalvojumu izmantošanas priekšrocības

Praktiski piemēri

1. piemērs: Pamata lietojums ar literāli

Bez `const` apgalvojuma TypeScript secina message tipu kā string:


const message = "Hello, World!"; // Tips: string

Ar `const` apgalvojumu TypeScript secina tipu kā literālo virkni "Hello, World!":


const message = "Hello, World!" as const; // Tips: "Hello, World!"

Tas ļauj izmantot literālo virknes tipu precīzākās tipu definīcijās un salīdzinājumos.

2. piemērs: `Const` apgalvojumu izmantošana ar masīviem

Apskatīsim krāsu masīvu:


const colors = ["red", "green", "blue"]; // Tips: string[]

Lai gan masīvs ir deklarēts ar const, jūs joprojām varat modificēt tā elementus:


colors[0] = "purple"; // Nav kļūdas
console.log(colors); // Izvade: ["purple", "green", "blue"]

Pievienojot `const` apgalvojumu, TypeScript secina masīvu kā `readonly` virkņu kortežu (tuple):


const colors = ["red", "green", "blue"] as const; // Tips: readonly ["red", "green", "blue"]

Tagad mēģinājums modificēt masīvu izraisīs TypeScript kļūdu:


// colors[0] = "purple"; // Kļūda: Indeksa paraksts tipā 'readonly ["red", "green", "blue"]' atļauj tikai lasīšanu.

Tas nodrošina, ka colors masīvs paliek nemainīgs.

3. piemērs: `Const` apgalvojumu izmantošana ar objektiem

Līdzīgi kā masīvus, arī objektus var padarīt nemainīgus ar `const` apgalvojumiem:


const person = {
  name: "Alice",
  age: 30,
}; // Tips: { name: string; age: number; }

Pat ar const, jūs joprojām varat modificēt person objekta īpašības:


person.age = 31; // Nav kļūdas
console.log(person); // Izvade: { name: "Alice", age: 31 }

Pievienojot `const` apgalvojumu, objekta īpašības kļūst readonly:


const person = {
  name: "Alice",
  age: 30,
} as const; // Tips: { readonly name: "Alice"; readonly age: 30; }

Tagad mēģinājums modificēt objektu izraisīs TypeScript kļūdu:


// person.age = 31; // Kļūda: Nevar piešķirt vērtību 'age', jo tā ir tikai lasāma īpašība.

4. piemērs: `Const` apgalvojumu izmantošana ar ligzdotiem objektiem un masīviem

`Const` apgalvojumus var piemērot ligzdotiem objektiem un masīviem, lai izveidotu dziļi nemainīgas datu struktūras. Apskatīsim šādu piemēru:


const config = {
  apiUrl: "https://api.example.com",
  endpoints: {
    users: "/users",
    products: "/products",
  },
  supportedLanguages: ["en", "fr", "de"],
} as const;

// Tips:
// {
//   readonly apiUrl: "https://api.example.com";
//   readonly endpoints: {
//     readonly users: "/users";
//     readonly products: "/products";
//   };
//   readonly supportedLanguages: readonly ["en", "fr", "de"];
// }

Šajā piemērā config objekts, tā ligzdotais endpoints objekts un supportedLanguages masīvs ir atzīmēti kā readonly. Tas nodrošina, ka nevienu konfigurācijas daļu nevar nejauši modificēt izpildes laikā.

5. piemērs: `Const` apgalvojumi ar funkciju atgrieztajiem tipiem

Jūs varat izmantot `const` apgalvojumus, lai nodrošinātu, ka funkcija atgriež nemainīgu vērtību. Tas ir īpaši noderīgi, veidojot palīgfunkcijas, kurām nevajadzētu modificēt savus ievades datus vai radīt mainīgu izvadi.


function createImmutableArray(items: T[]): readonly T[] {
  return [...items] as const;
}

const numbers = [1, 2, 3];
const immutableNumbers = createImmutableArray(numbers);

// immutableNumbers tips: readonly [1, 2, 3]

// immutableNumbers[0] = 4; // Kļūda: Indeksa paraksts tipā 'readonly [1, 2, 3]' atļauj tikai lasīšanu.

Lietošanas gadījumi un scenāriji

Konfigurācijas pārvaldība

`Const` apgalvojumi ir ideāli piemēroti lietojumprogrammu konfigurācijas pārvaldībai. Deklarējot savus konfigurācijas objektus ar as const, jūs varat nodrošināt, ka konfigurācija paliek nemainīga visā lietojumprogrammas dzīves ciklā. Tas novērš nejaušas modifikācijas, kas varētu izraisīt neparedzētu uzvedību.


const appConfig = {
  appName: "My Application",
  version: "1.0.0",
  apiEndpoint: "https://api.example.com",
} as const;

Konstanšu definēšana

`Const` apgalvojumi ir noderīgi arī konstanšu definēšanai ar specifiskiem literāliem tipiem. Tas var uzlabot tipu drošību un koda skaidrību.


const HTTP_STATUS_OK = 200 as const; // Tips: 200
const HTTP_STATUS_NOT_FOUND = 404 as const; // Tips: 404

Darbs ar Redux vai citām stāvokļa pārvaldības bibliotēkām

Stāvokļa pārvaldības bibliotēkās, piemēram, Redux, nemainīgums ir pamatprincips. `Const` apgalvojumi var palīdzēt ieviest nemainīgumu jūsu reduktoros (reducers) un darbību veidotājos (action creators), novēršot nejaušas stāvokļa mutācijas.


// Redux reduktora piemērs

interface State {
  readonly count: number;
}

const initialState: State = { count: 0 } as const;

function reducer(state: State = initialState, action: { type: string }): State {
  switch (action.type) {
    default:
      return state;
  }
}

Internacionalizācija (i18n)

Strādājot ar internacionalizāciju, jums bieži ir atbalstīto valodu un to atbilstošo lokalizācijas kodu kopa. `Const` apgalvojumi var nodrošināt, ka šī kopa paliek nemainīga, novēršot nejaušas pievienošanas vai modifikācijas, kas varētu salauzt jūsu i18n implementāciju. Piemēram, iedomājieties atbalstu angļu (en), franču (fr), vācu (de), spāņu (es) un japāņu (ja) valodām:


const supportedLanguages = ["en", "fr", "de", "es", "ja"] as const;

type SupportedLanguage = typeof supportedLanguages[number]; // Tips: "en" | "fr" | "de" | "es" | "ja"

function greet(language: SupportedLanguage) {
  switch (language) {
    case "en":
      return "Hello!";
    case "fr":
      return "Bonjour!";
    case "de":
      return "Guten Tag!";
    case "es":
      return "¡Hola!";
    case "ja":
      return "こんにちは!";
    default:
      return "Sveiciens šai valodai nav pieejams.";
  }
}

Ierobežojumi un apsvērumi

Alternatīvas `const` apgalvojumiem

Lai gan `const` apgalvojumi ir spēcīgs rīks nemainīguma ieviešanai, ir arī citas pieejas, ko varat apsvērt:

Labākā prakse

Noslēgums

TypeScript `const` apgalvojumi ir vērtīgs rīks nemainīguma ieviešanai un tipu drošības uzlabošanai jūsu kodā. Izmantojot as const, jūs varat norādīt kompilatoram secināt šaurāko iespējamo tipu vērtībai un atzīmēt visas īpašības kā readonly. Tas var palīdzēt novērst nejaušas modifikācijas, uzlabot koda paredzamību un nodrošināt precīzāku tipu pārbaudi. Lai gan `const` apgalvojumiem ir daži ierobežojumi, tie ir spēcīgs papildinājums TypeScript valodai un var ievērojami uzlabot jūsu lietojumprogrammu robustumu.

Stratēģiski iekļaujot `const` apgalvojumus savos TypeScript projektos, jūs varat rakstīt uzticamāku, uzturamāku un paredzamāku kodu. Izmantojiet nemainīgas tipu secināšanas spēku un paaugstiniet savas programmatūras izstrādes prakses.